# QueryMapper.java

    package org.codefilarete.stalactite.engine;

    import java.lang.reflect.Executable;
    import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;

    import org.codefilarete.reflection.MethodReferenceCapturer;
    import org.codefilarete.reflection.Mutator;
    import org.codefilarete.reflection.SerializableMutator;
    import org.codefilarete.stalactite.engine.runtime.BeanPersister;
    import org.codefilarete.stalactite.query.api.Selectable;
    import org.codefilarete.stalactite.query.builder.SQLBuilder;
    import org.codefilarete.stalactite.sql.ConnectionProvider;
    import org.codefilarete.stalactite.sql.result.Accumulator;
    import org.codefilarete.stalactite.sql.result.Accumulators;
    import org.codefilarete.stalactite.sql.result.BeanRelationFixer;
    import org.codefilarete.stalactite.sql.result.MultipleColumnsReader;
    import org.codefilarete.stalactite.sql.result.ResultSetRowAssembler;
    import org.codefilarete.stalactite.sql.result.ResultSetRowTransformer;
    import org.codefilarete.stalactite.sql.result.SingleColumnReader;
    import org.codefilarete.stalactite.sql.result.WholeResultSetTransformer;
    import org.codefilarete.stalactite.sql.result.WholeResultSetTransformer.AssemblyPolicy;
    import org.codefilarete.stalactite.sql.statement.ReadOperation;
    import org.codefilarete.stalactite.sql.statement.ReadOperationFactory;
    import org.codefilarete.stalactite.sql.statement.StringParamedSQL;
    import org.codefilarete.stalactite.sql.statement.binder.ColumnBinderRegistry;
    import org.codefilarete.stalactite.sql.statement.binder.NullAwareParameterBinder;
    import org.codefilarete.stalactite.sql.statement.binder.ParameterBinder;
    import org.codefilarete.tool.Reflections;
    import org.codefilarete.tool.collection.Arrays;
    import org.codefilarete.tool.collection.Iterables;
    import org.codefilarete.tool.function.Converter;
    import org.codefilarete.tool.function.SerializableTriFunction;
    import org.danekja.java.util.function.serializable.SerializableBiFunction;
    import org.danekja.java.util.function.serializable.SerializableFunction;
    import org.danekja.java.util.function.serializable.SerializableSupplier;

    import static org.codefilarete.stalactite.sql.statement.binder.NullAwareParameterBinder.ALWAYS_SET_NULL_INSTANCE;
    import static org.codefilarete.tool.bean.Objects.preventNull;

    /**
     * A class aimed at querying the database and creating Java beans from it.
     * Beans resulting of it are not expected to be used as entity and given to {@link BeanPersister}, noticibly for insert
     * or update, because one should ensure that fields read from its query must be the same as those done by {@link BeanPersister}, otherwise it may
     * result in column value erasure.
     *
     * @author Guillaume Mary
     */
    public class QueryMapper<C> implements BeanKeyQueryMapper<C>, BeanPropertyQueryMapper<C> {

    	/** Default method capturer. Shared to cache result of each lookup. */
    	private static final MethodReferenceCapturer METHOD_REFERENCE_CAPTURER = new MethodReferenceCapturer();

    	/** The method capturer (when column types are not given by {@link BeanPropertyQueryMapper#map(String, SerializableMutator)}) */
    	private final MethodReferenceCapturer methodReferenceCapturer;

    	/** Type of bean that will be built by {@link #execute(ConnectionProvider)} */
    	private final Class<C> rootBeanType;

    	/** The sql provider */
    	private final SQLBuilder sqlBuilder;

    	/** The registry of {@link ParameterBinder}s, for column reading as well as sql argument setting */
    	private final ColumnBinderRegistry columnBinderRegistry;

    	/** {@link ParameterBinder}s per ({@link java.sql.PreparedStatement}) parameter */
    	private final Map<String, ParameterBinder<?>> sqlParameterBinders = new HashMap<>();

    	/** SQL argument values (for where clause, or anywhere else) */
    	private final Map<String, Object> sqlArguments = new HashMap<>();

    	/** Delegate for {@link java.sql.ResultSet} transformation, will get all the mapping configuration */
    	private WholeResultSetTransformer<C, ?> rootTransformer;

    	private final QueryMapping<C, ?> mapping = new QueryMapping<>();

    	private final ReadOperationFactory readOperationFactory;

    	private final Map<Selectable<?>, String> aliases = new HashMap<>();

    	/**
    	 * Simple constructor
    	 *
    	 * @param rootBeanType type of built bean
    	 * @param sqlBuilder the sql to execute
    	 * @param columnBinderRegistry a provider for SQL parameters and selected column
    	 */
    	public QueryMapper(Class<C> rootBeanType,
    					   CharSequence sqlBuilder,
    					   ColumnBinderRegistry columnBinderRegistry,
    					   ReadOperationFactory readOperationFactory) {
    		this(rootBeanType, sqlBuilder, columnBinderRegistry, METHOD_REFERENCE_CAPTURER, readOperationFactory);
    	}

    	/**
    	 * Simple constructor
    	 *
    	 * @param rootBeanType type of built bean
    	 * @param sqlBuilder the sql provider
    	 * @param columnBinderRegistry a provider for SQL parameters and selected column
    	 */
    	public QueryMapper(Class<C> rootBeanType,
    					   SQLBuilder sqlBuilder,
    					   ColumnBinderRegistry columnBinderRegistry,
    					   ReadOperationFactory readOperationFactory) {
    		this(rootBeanType, sqlBuilder, columnBinderRegistry, METHOD_REFERENCE_CAPTURER, readOperationFactory);
    	}

    	/**
    	 * Constructor to share {@link MethodReferenceCapturer} between instance of {@link QueryMapper}
    	 *
    	 * @param rootBeanType type of built bean
    	 * @param sqlBuilder the sql to execute
    	 * @param columnBinderRegistry a provider for SQL parameters and selected column
    	 * @param methodReferenceCapturer a method capturer (when column types are not given by {@link BeanPropertyQueryMapper#map(String, SerializableMutator)}),
    	 * default is {@link #METHOD_REFERENCE_CAPTURER}
    	 */
    	public QueryMapper(Class<C> rootBeanType,
    					   CharSequence sqlBuilder,
    					   ColumnBinderRegistry columnBinderRegistry,
    					   MethodReferenceCapturer methodReferenceCapturer,
    					   ReadOperationFactory readOperationFactory) {
    		this(rootBeanType, () -> sqlBuilder, columnBinderRegistry, methodReferenceCapturer, readOperationFactory);
    	}

    	/**
    	 * Constructor to share {@link MethodReferenceCapturer} between instance of {@link QueryMapper}
    	 *
    	 * @param rootBeanType type of built bean
    	 * @param sqlBuilder the sql provider
    	 * @param columnBinderRegistry a provider for SQL parameters and selected column
    	 * @param methodReferenceCapturer a method capturer (when column types are not given by {@link BeanPropertyQueryMapper#map(String, SerializableMutator)}),
    	 * default is {@link #METHOD_REFERENCE_CAPTURER}
    	 */
    	public QueryMapper(Class<C> rootBeanType,
    					   SQLBuilder sqlBuilder,
    					   ColumnBinderRegistry columnBinderRegistry,
    					   MethodReferenceCapturer methodReferenceCapturer,
    					   ReadOperationFactory readOperationFactory) {
    		this.rootBeanType = rootBeanType;
    		this.sqlBuilder = sqlBuilder;
    		this.columnBinderRegistry = columnBinderRegistry;
    		this.methodReferenceCapturer = methodReferenceCapturer;
    		this.readOperationFactory = readOperationFactory;
    	}

    	public void setColumnAliases(Map<Selectable<?>, String> aliases) {
    		this.aliases.putAll(aliases);
    	}

    	@Override
    	public QueryMapper<C> mapKey(SerializableSupplier<C> factory) {
    		this.rootTransformer = new WholeResultSetTransformer<>(rootBeanType, factory);
    		return this;
    	}

    	@Override
    	public <I> QueryMapper<C> mapKey(SerializableFunction<I, C> factory, String columnName) {
    		MethodReferenceCapturer methodReferenceCapturer = new MethodReferenceCapturer();
    		// Looking for column type (necessary to know how to read ResultSet) by looking to first argument of given function
    		// (which can be either a constructor or a method factory)
    		Executable executable = methodReferenceCapturer.findExecutable(factory);
    		this.rootTransformer = buildSingleColumnKeyTransformer(new ColumnDefinition<>(columnName, (Class<I>) executable.getParameterTypes()[0]), factory);
    		return this;
    	}

    	@Override
    	public <I, J> QueryMapper<C> mapKey(SerializableBiFunction<I, J, C> factory, String column1, String column2) {
    		MethodReferenceCapturer methodReferenceCapturer = new MethodReferenceCapturer();
    		// Looking for column type (necessary to know how to read ResultSet) by looking to first argument of given function
    		// (which can be either a constructor or a method factory)
    		Executable executable = methodReferenceCapturer.findExecutable(factory);
    		SerializableFunction<Object[], C> constructorInvokation = args -> (C) factory.apply((I) args[0], (J) args[1]);
    		this.rootTransformer = buildComposedKeyTransformer(Arrays.asSet(
    				new ColumnDefinition<>(column1, executable.getParameterTypes()[0]),
    				new ColumnDefinition<>(column2, executable.getParameterTypes()[1])),
    				constructorInvokation);
    		return this;
    	}

    	@Override
    	public <I, J, K> QueryMapper<C> mapKey(SerializableTriFunction<I, J, K, C> factory, String column1, String column2, String column3) {
    		MethodReferenceCapturer methodReferenceCapturer = new MethodReferenceCapturer();
    		Executable executable = methodReferenceCapturer.findExecutable(factory);
    		// Looking for column type (necessary to know how to read ResultSet) by looking to first argument of given function
    		// (which can be either a constructor or a method factory)
    		SerializableFunction<Object[], C> constructorInvokation = args -> (C) factory.apply((I) args[0], (J) args[1], (K) args[2]);
    		this.rootTransformer = buildComposedKeyTransformer(Arrays.asSet(
    				new ColumnDefinition<>(column1, executable.getParameterTypes()[0]),
    				new ColumnDefinition<>(column2, executable.getParameterTypes()[1]),
    				new ColumnDefinition<>(column3, executable.getParameterTypes()[2])),
    				constructorInvokation);
    		return this;
    	}

    	/**
    	 * Defines the key column and the way to create the bean : a constructor with the key as parameter.
    	 *
    	 * @param <I> the type of the column, which is also that of the factory argument
    	 * @param factory the factory function that will instantiate new beans (with key as single argument)
    	 * @param columnName the key column name
    	 * @param columnType the type of the column, which is also that of the factory argument
    	 * @return this
    	 */
    	@Override
    	public <I> QueryMapper<C> mapKey(SerializableFunction<I, C> factory, String columnName, Class<I> columnType) {
    		this.rootTransformer = buildSingleColumnKeyTransformer(new ColumnDefinition<>(columnName, columnType), factory);
    		return this;
    	}

    	/**
    	 * Defines key columns and the way to create the bean : a constructor with 2 arguments.
    	 *
    	 * @param <I> the type of the column, which is also that of the factory argument
    	 * @param factory the factory function that will instantiate new beans (with key as single argument)
    	 * @param column1Name the first key column name
    	 * @param column1Type the type of the first column, which is also that of the factory first argument
    	 * @param column2Name the second key column name
    	 * @param column2Type the type of the second column, which is also that of the factory second argument
    	 * @return this
    	 */
    	@Override
    	public <I, J> QueryMapper<C> mapKey(SerializableBiFunction<I, J, C> factory, String column1Name, Class<I> column1Type,
    										String column2Name, Class<J> column2Type) {
    		SerializableFunction<Object[], C> constructorInvokation = args -> (C) factory.apply((I) args[0], (J) args[1]);
    		this.rootTransformer = buildComposedKeyTransformer(Arrays.asSet(
    				new ColumnDefinition<>(column1Name, column1Type),
    				new ColumnDefinition<>(column2Name, column2Type)),
    				constructorInvokation);
    		return this;
    	}

    	/**
    	 * Defines key columns and the way to create the bean : a constructor with 3 arguments.
    	 *
    	 * @param <I> the type of the column, which is also that of the factory argument
    	 * @param factory the factory function that will instantiate new beans (with key as single argument)
    	 * @param column1Name the first key column name
    	 * @param column1Type the type of the first column, which is also that of the factory first argument
    	 * @param column2Name the second key column name
    	 * @param column2Type the type of the second column, which is also that of the factory second argument
    	 * @param column3Name the third key column name
    	 * @param column3Type the type of the third column, which is also that of the factory third argument
    	 * @return this
    	 */
    	@Override
    	public <I, J, K> QueryMapper<C> mapKey(SerializableTriFunction<I, J, K, C> factory, String column1Name, Class<I> column1Type,
    										   String column2Name, Class<J> column2Type,
    										   String column3Name, Class<K> column3Type) {
    		SerializableFunction<Object[], C> constructorInvokation = args -> (C) factory.apply((I) args[0], (J) args[1], (K) args[2]);
    		this.rootTransformer = buildComposedKeyTransformer(Arrays.asSet(
    				new ColumnDefinition<>(column1Name, column1Type),
    				new ColumnDefinition<>(column2Name, column2Type),
    				new ColumnDefinition<>(column3Name, column3Type)),
    				constructorInvokation);
    		return this;
    	}

    	/**
    	 * Same as {@link #mapKey(SerializableFunction, String, Class)} but with {@link Selectable} signature
    	 *
    	 * @param <I> type of the key
    	 * @param factory the factory function that will instantiate new beans (with key as single argument)
    	 * @param column the mapped column used as a key
    	 * @return this
    	 */
    	@Override
    	public <I> QueryMapper<C> mapKey(SerializableFunction<I, C> factory,
    									 Selectable<I> column) {
    		this.rootTransformer = buildSingleColumnKeyTransformer(new ColumnWrapper<>(column), factory);
    		return this;
    	}

    	/**
    	 * Same as {@link #mapKey(SerializableFunction, Selectable)} with a 2-args constructor
    	 *
    	 * @param <I> type of the key
    	 * @param factory the factory function that will instantiate new beans (with key as single argument)
    	 * @param column1 the first column of the key
    	 * @param column2 the second column of the key
    	 * @return this
    	 */
    	@Override
    	public <I, J> QueryMapper<C> mapKey(SerializableBiFunction<I, J, C> factory,
    										Selectable<I> column1,
    										Selectable<J> column2
    	) {
    		SerializableFunction<Object[], C> constructorInvokation = args -> (C) factory.apply((I) args[0], (J) args[1]);
    		this.rootTransformer = buildComposedKeyTransformer(Arrays.asSet(
    				new ColumnWrapper<>(column1),
    				new ColumnWrapper<>(column2)),
    				constructorInvokation);
    		return this;
    	}

    	/**
    	 * Same as {@link #mapKey(SerializableFunction, Selectable)} with a 3-args constructor
    	 *
    	 * @param <I> type of the key
    	 * @param factory the factory function that will instantiate new beans (with key as single argument)
    	 * @param column1 the first column of the key
    	 * @param column2 the second column of the key
    	 * @param column3 the third column of the key
    	 * @return this
    	 */
    	@Override
    	public <I, J, K> QueryMapper<C> mapKey(SerializableTriFunction<I, J, K, C> factory,
    										   Selectable<I> column1,
    										   Selectable<J> column2,
    										   Selectable<K> column3
    	) {
    		SerializableFunction<Object[], C> constructorInvokation = args -> (C) factory.apply((I) args[0], (J) args[1], (K) args[2]);
    		this.rootTransformer = buildComposedKeyTransformer(Arrays.asSet(
    				new ColumnWrapper<>(column1),
    				new ColumnWrapper<>(column2),
    				new ColumnWrapper<>(column3)),
    				constructorInvokation);
    		return this;
    	}

    	@Override
    	public <I> QueryMapper<I> mapKey(String columnName, Class<I> columnType) {
    		this.rootTransformer = (WholeResultSetTransformer<C, ?>) buildSingleColumnKeyTransformer(new ColumnDefinition<>(columnName, columnType), SerializableFunction.identity());
    		return (QueryMapper<I>) this;
    	}

    	/**
    	 * Defines a mapping between a column of the query and a bean property through its setter
    	 *
    	 * @param columnName a column name
    	 * @param setter the setter function
    	 * @param columnType the type of the column, which is also that of the setter argument
    	 * @param <I> the type of the column, which is also that of the setter argument
    	 * @return this
    	 */
    	@Override
    	public <I> QueryMapper<C> map(String columnName, Mutator<C, I> setter, Class<I> columnType) {
    		map(new ColumnMapping<>(columnName, setter, columnType));
    		return this;
    	}

    	/**
    	 * Same as {@link BeanPropertyQueryMapper#map(String, Mutator, Class)}.
    	 * Differs by providing the possiblity to convert the value before setting it onto the bean.
    	 *
    	 * @param columnName a column name
    	 * @param setter the setter function
    	 * @param columnType the type of the column, which is also that of the setter argument
    	 * @param converter a converter of the read value from ResultSet
    	 * @param <I> the type of the setter argument, which is also that of the converter result
    	 * @param <J> the type of the column, which is also that of the converter argument
    	 * @return this
    	 */
    	@Override
    	public <I, J> QueryMapper<C> map(String columnName, SerializableMutator<C, J> setter, Class<I> columnType, Converter<I, J> converter) {
    		return map(columnName, (c, i) -> setter.set(c, converter.convert(i)), columnType);
    	}

    	/**
    	 * Defines a mapping between a column of the query and a bean property through its setter.
    	 * WARNING : Column type will be deduced from the setter type. To do it, some bytecode enhancement is required, therefore it's not the cleanest
    	 * way to define the binding. Prefer {@link BeanPropertyQueryMapper#map(String, Mutator, Class)}
    	 *
    	 * @param columnName a column name
    	 * @param setter the setter function
    	 * @param <I> the type of the column, which is also that of the setter argument
    	 * @return this
    	 */
    	@Override
    	public <I> QueryMapper<C> map(String columnName, SerializableMutator<C, I> setter) {
    		map(columnName, setter, giveColumnType(setter));
    		return this;
    	}

    	/**
    	 * Same as {@link BeanPropertyQueryMapper#map(String, SerializableMutator)}.
    	 * Differs by providing the possibility to convert the value before setting it onto the bean.
    	 *
    	 * @param columnName a column name
    	 * @param setter the setter function
    	 * @param converter a converter of the read value from ResultSet
    	 * @param <I> the type of the setter argument, which is also that of the converter result
    	 * @return this
    	 */
    	@Override
    	public <I, J> QueryMapper<C> map(String columnName, SerializableMutator<C, J> setter, Converter<I, J> converter) {
    		Method method = methodReferenceCapturer.findMethod(setter);
    		Class<I> aClass = (Class<I>) method.getParameterTypes()[0];
    		return map(columnName, (c, i) -> setter.set(c, converter.convert(i)), aClass);
    	}

    	/**
    	 * Same as {@link BeanPropertyQueryMapper#map(String, Mutator, Class)} but with {@link Selectable} signature
    	 *
    	 * @param column the mapped column
    	 * @param setter the setter function
    	 * @param <I> the type of the column, which is also that of the setter argument
    	 * @return this
    	 */
    	@Override
    	public <I> QueryMapper<C> map(Selectable<I> column, Mutator<C, I> setter) {
    		map(new ColumnMapping<>(column, setter));
    		return this;
    	}

    	/**
    	 * Same as {@link BeanPropertyQueryMapper#map(Selectable, Mutator)}.
    	 * Differs by providing the possibility to convert the value before setting it onto the bean.
    	 *
    	 * @param column the mapped column
    	 * @param setter the setter function
    	 * @param converter a converter of the read value from ResultSet
    	 * @param <I> the type of the setter argument, which is also that of the converter result
    	 * @param <J> the type of the column, which is also that of the converter argument
    	 * @return this
    	 */
    	@Override
    	public <I, J> QueryMapper<C> map(Selectable<I> column,
    									 Mutator<C, J> setter,
    									 Converter<I, J> converter) {
    		return map(column, (c, i) -> setter.set(c, converter.convert(i)));
    	}

    	private <I> void map(ColumnMapping<C, I> columnMapping) {
    		mapping.add((ColumnMapping) columnMapping);
    	}

    	/** Overridden to adapt return type */
    	@Override
    	public QueryMapper<C> map(ResultSetRowAssembler<C> assembler) {
    		return map(assembler, AssemblyPolicy.ON_EACH_ROW);
    	}

    	@Override
    	public QueryMapper<C> map(ResultSetRowAssembler<C> assembler, AssemblyPolicy assemblyPolicy) {
    		mapping.add(assembler, assemblyPolicy);
    		return this;
    	}

    	@Override
    	public <K, V> QueryMapper<C> map(BeanRelationFixer<C, V> combiner, ResultSetRowTransformer<V, K> relatedBeanCreator) {
    		mapping.add((BeanRelationFixer) combiner, relatedBeanCreator);
    		return this;
    	}

    	/**
    	 * Executes the query onto the connection given by the {@link ConnectionProvider}. Transforms the result to a list of beans thanks to the
    	 * definition given through {@link #mapKey(SerializableFunction, String, Class)}, {@link BeanPropertyQueryMapper#map(String, Mutator, Class)}
    	 * and {@link BeanPropertyQueryMapper#map(String, SerializableMutator)} methods.
    	 *
    	 * @param connectionProvider the object that will give the {@link java.sql.Connection}
    	 * @return a {@link Set} filled by the instances built
    	 */
    	public Set<C> execute(ConnectionProvider connectionProvider) {
    		return execute(connectionProvider, Accumulators.toSet());
    	}

    	public <R> R execute(ConnectionProvider connectionProvider, Accumulator<C, ?, R> accumulator) {
    		WholeResultSetTransformer<C, ?> transformerToUse;
    		if (rootTransformer == null) {
    			// No key defined (none of mapKey(..) methods were invoked), therefore we'll use default (no-arg) constructor
    			transformerToUse = new WholeResultSetTransformer<>(rootBeanType, () -> Reflections.newInstance(rootBeanType));
    		} else {
    			transformerToUse = rootTransformer;
    		}
    		this.mapping.applyTo((WholeResultSetTransformer) transformerToUse);
    		StringParamedSQL parameterizedSQL = new StringParamedSQL(this.sqlBuilder.toSQL().toString(), sqlParameterBinders);
    		parameterizedSQL.setValues(sqlArguments);
    		try (ReadOperation<String> readOperation = readOperationFactory.createInstance(parameterizedSQL, connectionProvider)) {
    			return transformerToUse.transformAll(readOperation.execute(), accumulator);
    		}
    	}

    	private <I, O> WholeResultSetTransformer<O, I> buildSingleColumnKeyTransformer(Column<I> keyColumn, SerializableFunction<I, O> beanFactory) {
    		return new WholeResultSetTransformer<>((Class<O>) rootBeanType, keyColumn.getName(), keyColumn.getBinder(), beanFactory);
    	}

    	private WholeResultSetTransformer<C, Object[]> buildComposedKeyTransformer(Set<Column> columns, SerializableFunction<Object[], C> beanFactory) {
    		Map<Column<?>, String> computedAliases = new HashMap<>();
    		Set<SingleColumnReader> columnReaders = Iterables.collect(columns, c -> {
    			ParameterBinder reader = c.getBinder();
    			String alias;
    			if (c instanceof ColumnWrapper) {
    				alias = preventNull(aliases.get(((ColumnWrapper<?>) c).getColumn()), c.getName());
    			} else {
    				alias = c.getName();
    			}
    			computedAliases.put(c, alias);
    			return new SingleColumnReader<>(alias, reader);
    		}, HashSet::new);
    		MultipleColumnsReader<Object[]> multipleColumnsReader = new MultipleColumnsReader<>(columnReaders, resultSetRow -> {
    			// we transform all columns value into a Object[]
    			Object[] constructorArgs = new Object[columns.size()];
    			int i = 0;
    			for (Column column : columns) {
    				constructorArgs[i++] = resultSetRow.get(computedAliases.get(column));
    			}
    			return constructorArgs;
    		});

    		ResultSetRowTransformer<C, Object[]> resultSetRowConverter = new ResultSetRowTransformer<>(
    				rootBeanType,
    				multipleColumnsReader,
    				beanFactory);
    		return new WholeResultSetTransformer<>(resultSetRowConverter);
    	}

    	private <I> Class<I> giveColumnType(SerializableMutator<C, I> setter) {
    		Method method = methodReferenceCapturer.findMethod(setter);
    		// we could take the first parameter type, but with a particular syntax of setter it's insufficient, last element is better
    		return (Class<I>) Arrays.last(method.getParameterTypes());
    	}

    	/**
    	 * Sets a value for a SQL parameter. Not to be used with Collection/Iterable value : see {@link #set(String, Iterable, Class)} dedicated method for it.
    	 * No check for "already set" argument is done, so one can overwrite/redefine an existing value. This lets one reexecutes a
    	 * {@link QueryMapper} with different parameters.
    	 *
    	 * @param paramName the name of the SQL parameter to be set
    	 * @param value the value of the parameter, null is authorized but since type can't be know in this case {@link java.sql.PreparedStatement#setObject(int, Object)}
    	 * 				will be used, so prefer {@link #set(String, Object, Class)} if your database driver doesn't support well setObject(..),
    	 * 			    see	{@link NullAwareParameterBinder#ALWAYS_SET_NULL_INSTANCE}
    	 * @return this
    	 * @see #set(String, Iterable, Class)
    	 */
    	public QueryMapper<C> set(String paramName, Object value) {
    		return set(paramName, value, value == null ? null : (Class) value.getClass());
    	}

    	/**
    	 * Sets a value for a SQL parameter. Not for Collection/Iterable value : see {@link #set(String, Iterable, Class)} dedicated method for it.
    	 * No check for "already set" argument is done, so one can overwrite/redefine an existing value. This lets one reexecutes a
    	 * {@link QueryMapper} with different parameters.
    	 *
    	 * @param paramName the name of the SQL parameter to be set
    	 * @param value the value of the parameter
    	 * @param valueType the content type of the {@link Iterable}, more exactly will determine which {@link ParameterBinder} to be used
    	 * @return this
    	 * @see #set(String, Iterable, Class)
    	 */
    	public <O> QueryMapper<C> set(String paramName, O value, Class<? super O> valueType) {
    		ParameterBinder<?> parameterBinder;
    		if (value == null) {
    			parameterBinder = ALWAYS_SET_NULL_INSTANCE;
    		} else {
    			if (value.getClass().isArray()) {
    				valueType = (Class<? super O>) Iterables.first((Object[]) value);
    			} else if (Iterable.class.isAssignableFrom(value.getClass())) {
    				valueType = (Class<? super O>) Iterables.first((Iterable) value).getClass();
    			}
    			parameterBinder = columnBinderRegistry.getBinder(valueType);
    		}
    		this.sqlParameterBinders.put(paramName, parameterBinder);
    		this.sqlArguments.put(paramName, value);
    		return this;
    	}

    	/**
    	 * Sets a value for a Collection/Iterable SQL argument. Must be distinguished from {@link #set(String, Object)} because real {@link Iterable}
    	 * content type guessing can be difficult (or at least not accurate) and can lead to {@link Iterable} consumption.
    	 * No check for "already set" argument is done, so one can overwrite/redefine an existing value. This lets one reexecutes a
    	 * {@link QueryMapper} with different parameters.
    	 *
    	 * @param paramName the name of the SQL parameter to be set
    	 * @param value the value of the parameter
    	 * @param valueType the content type of the {@link Iterable}, more exactly will determine which {@link ParameterBinder} to be used
    	 * @return this
    	 */
    	public <O> QueryMapper<C> set(String paramName, Iterable<O> value, Class<? super O> valueType) {
    		this.sqlParameterBinders.put(paramName, value == null ? ALWAYS_SET_NULL_INSTANCE : columnBinderRegistry.getBinder(valueType));
    		this.sqlArguments.put(paramName, value);
    		return this;
    	}

    	/**
    	 * An internal definition of a "column" : a selected column or a statement parameter
    	 * @param <T> the value type of the "column"
    	 */
    	private interface Column<T> {

    		String getName();

    		ParameterBinder<T> getBinder();
    	}

    	private class ColumnDefinition<T> implements QueryMapper.Column<T> {

    		private final String name;

    		private final Class<T> valueType;

    		private ColumnDefinition(String name, Class<T> valueType) {
    			this.name = name;
    			this.valueType = valueType;
    		}

    		public String getName() {
    			return name;
    		}

    		public ParameterBinder<T> getBinder() {
    			return columnBinderRegistry.getBinder(valueType);
    		}
    	}

    	private class ColumnWrapper<T> implements QueryMapper.Column<T> {

    		private final Selectable<T> column;

    		private ColumnWrapper(Selectable<T> column) {
    			this.column = column;
    		}

    		public String getName() {
    			return column.getExpression();
    		}

    		public ParameterBinder<T> getBinder() {
    			if (column instanceof org.codefilarete.stalactite.sql.ddl.structure.Column) {
    				return columnBinderRegistry.getBinder((org.codefilarete.stalactite.sql.ddl.structure.Column<?, T>) column);
    			} else {
    				return columnBinderRegistry.getBinder(column.getJavaType());
    			}
    		}

    		public Selectable<T> getColumn() {
    			return column;
    		}
    	}

    	/**
    	 * An internal class defining the way to map a result column to a bean "property" (more precisely a setter or whatever which takes the value as input)
    	 *
    	 * @param <T> the bean type that supports the setter
    	 * @param <I> the column value type which is also the input type of the property setter
    	 */
    	private class ColumnMapping<T, I> {

    		private final QueryMapper.Column<I> column;

    		private final Mutator<T, I> setter;

    		public ColumnMapping(String columnName, Mutator<T, I> setter, Class<I> columnType) {
    			this.column = new ColumnDefinition<>(columnName, columnType);
    			this.setter = setter;
    		}

    		public ColumnMapping(Selectable<I> column, Mutator<T, I> setter) {
    			this.column = new ColumnWrapper<>(column);
    			this.setter = setter;
    		}

    		public QueryMapper.Column<I> getColumn() {
    			return column;
    		}

    		public Mutator<T, I> getSetter() {
    			return setter;
    		}
    	}

    	/**
    	 * Stores configuration defined by user to let user uses {@link QueryMapper} methods in any order : without it mapKey(..) should be used first
    	 * because we might have to apply mapping to {@link WholeResultSetTransformer} instance
    	 *
    	 * @param <C> created instance type
    	 * @param <I> identifier type
    	 */
    	private static class QueryMapping<C, I> {

    		private final List<Mapping> mappings = new ArrayList<>(10);

    		public void add(QueryMapper<C>.ColumnMapping<C, I> columnMapping) {
    			mappings.add(new ColumnMapping(columnMapping));
    		}

    		public void add(ResultSetRowAssembler<C> assembler, AssemblyPolicy assemblyPolicy) {
    			mappings.add(new AssemblerMapping(assembler, assemblyPolicy));
    		}

    		public <K, V> void add(BeanRelationFixer<K, V> combiner, ResultSetRowTransformer<V, K> relatedBeanCreator) {
    			mappings.add(new RelationMapping(combiner, relatedBeanCreator));
    		}

    		/**
    		 * Transfer this mapping to given instance
    		 * @param target instance that will consume current mapping
    		 */
    		public void applyTo(WholeResultSetTransformer<C, I> target) {
    			this.mappings.forEach(m -> {
    				if (m instanceof ColumnMapping) {
    					QueryMapper.ColumnMapping columnMapping = ((ColumnMapping) m).columnMapping;
    					target.add(columnMapping.getColumn().getName(), columnMapping.getColumn().getBinder(), columnMapping.getSetter());
    				} else if (m instanceof AssemblerMapping) {
    					AssemblerMapping assemblerMapping = (AssemblerMapping) m;
    					target.add(assemblerMapping.assembler, assemblerMapping.policy);
    				} else if (m instanceof RelationMapping) {
    					RelationMapping relationMapping = (RelationMapping) m;
    					target.add((BeanRelationFixer<C, Object>) relationMapping.combiner::apply, relationMapping.relatedBeanCreator);
    				}
    			});
    		}

    		/**
    		 * A marking interface for different kind of mapping configurations, made to allow them being stored in {@link java.util.Collection}.
    		 * Only used by {@link QueryMapping}
    		 */
    		private interface Mapping {

    		}

    		/** Simple store for property-column mapping */
    		private static class ColumnMapping implements Mapping {
    			private final QueryMapper.ColumnMapping columnMapping;

    			private ColumnMapping(QueryMapper.ColumnMapping columnMapping) {
    				this.columnMapping = columnMapping;
    			}
    		}

    		/** Simple store for assembly mapping */
    		private static class AssemblerMapping implements Mapping {
    			private final ResultSetRowAssembler assembler;
    			private final AssemblyPolicy policy;

    			private AssemblerMapping(ResultSetRowAssembler assembler, AssemblyPolicy policy) {
    				this.assembler = assembler;
    				this.policy = policy;
    			}
    		}

    		/** Simple store for relation mapping */
    		private static class RelationMapping implements Mapping {
    			private final BeanRelationFixer combiner;
    			private final ResultSetRowTransformer relatedBeanCreator;

    			private RelationMapping(BeanRelationFixer combiner, ResultSetRowTransformer relatedBeanCreator) {
    				this.combiner = combiner;
    				this.relatedBeanCreator = relatedBeanCreator;
    			}
    		}
    	}
    }